// WebSocket服务配置和Mock功能

class WebSocketService {
  constructor() {
    this.socket = null;
    this.isConnected = false;
    this.messageHandlers = new Map();
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
    this.reconnectDelay = 1000;
    this.isMockMode = true; // 默认使用mock模式，会在init中被覆盖
    this.wsUrl = ''; // WebSocket地址
    this.messageId = 0; // 消息ID计数器
    this.requestQueue = new Map(); // 存储请求的回调函数
  }

  // 初始化WebSocket连接
  init({ wsUrl, enableMock = true }) {
    this.wsUrl = wsUrl; // 保存URL
    this.isMockMode = enableMock; // 使用传入的enableMock参数
    
    if (this.isMockMode) {
      // 使用Mock模式，模拟连接成功
      setTimeout(() => {
        this.isConnected = true;
        this.notifyHandlers('connection', { type: 'open', mock: true });
      }, 100);
      console.log('WebSocket服务初始化完成（使用Mock模式）', { wsUrl });
    } else {
      // 使用真实WebSocket连接
      this.connect();
      console.log('WebSocket服务初始化完成（准备连接真实服务器）', { wsUrl });
    }
  }

  // 建立WebSocket连接
  connect() {
    if (this.isMockMode || this.isConnected) return;
    
    try {
      console.log(`正在连接到WebSocket服务器: ${this.wsUrl}`);
      this.socket = new WebSocket(this.wsUrl);
      
      this.socket.onopen = () => {
        console.log('WebSocket连接已建立');
        this.isConnected = true;
        this.reconnectAttempts = 0;
        this.notifyHandlers('connection', { type: 'open', mock: false });
        // 重连后处理队列中的消息
        this.processRequestQueue();
      };

      this.socket.onmessage = (event) => {
        try {
          const data = JSON.parse(event.data);
          console.log('收到WebSocket消息:', data);
          this.handleMessage(data);
        } catch (error) {
          console.error('处理WebSocket消息失败:', error);
          this.notifyHandlers('error', { type: 'parse_error', error: error.message });
        }
      };

      this.socket.onclose = (event) => {
        console.log('WebSocket连接已关闭', event.code, event.reason);
        this.isConnected = false;
        this.notifyHandlers('connection', { type: 'close', code: event.code, reason: event.reason });
        if (!event.wasClean) {
          this.attemptReconnect();
        }
      };

      this.socket.onerror = (error) => {
        console.error('WebSocket错误:', error);
        this.notifyHandlers('connection', { type: 'error', error: error.message || String(error) });
      };
    } catch (error) {
      console.error('创建WebSocket连接失败:', error);
      this.notifyHandlers('connection', { type: 'error', error: error.message });
      this.attemptReconnect();
    }
  }

  // 尝试重连
  attemptReconnect() {
    if (this.isMockMode || this.reconnectAttempts >= this.maxReconnectAttempts) return;
    
    this.reconnectAttempts++;
    const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 30000); // 指数退避，最大30秒
    console.log(`尝试重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts})... 延迟${delay}ms`);
    
    setTimeout(() => {
      this.connect();
    }, delay + Math.random() * 1000); // 添加随机延迟避免惊群效应
  }
  
  // 处理请求队列
  processRequestQueue() {
    if (this.requestQueue.size === 0) return;
    
    console.log(`处理${this.requestQueue.size}个排队中的请求`);
    for (const [messageId, { type, payload }] of this.requestQueue.entries()) {
      this.send(type, payload);
    }
    this.requestQueue.clear();
  }

  // 处理接收到的消息
  handleMessage(data) {
    const { type, payload, messageId } = data;
    
    // 如果消息有ID，检查是否是特定请求的响应
    if (messageId && this.requestQueue.has(messageId)) {
      const { resolve } = this.requestQueue.get(messageId);
      if (resolve) {
        resolve({ type, payload });
      }
      this.requestQueue.delete(messageId);
    }
    
    // 通知所有相关处理器
    this.notifyHandlers(type, payload);
  }
  
  // 生成唯一消息ID
  generateMessageId() {
    return ++this.messageId;
  }

  // 发送消息
  send(type, payload) {
    const messageId = this.generateMessageId();
    const message = { type, payload, messageId, timestamp: Date.now() };
    
    console.log(`发送消息:`, message);
    
    if (this.isMockMode) {
      // Mock响应处理
      this.handleMockResponse(type, payload, messageId);
      return;
    }
    
    const messageString = JSON.stringify(message);
    
    if (this.isConnected && this.socket) {
      try {
        this.socket.send(messageString);
      } catch (error) {
        console.error('发送消息失败:', error);
        this.queueRequest(messageId, type, payload);
      }
    } else {
      console.warn('WebSocket未连接，将请求加入队列');
      this.queueRequest(messageId, type, payload);
    }
  }
  
  // 队列请求
  queueRequest(messageId, type, payload) {
    // 仅在非Mock模式下队列请求
    if (!this.isMockMode) {
      this.requestQueue.set(messageId, { type, payload });
      // 如果未连接，尝试连接
      if (!this.isConnected && this.wsUrl) {
        this.connect();
      }
    }
  }
  
  // 发送消息并等待响应（Promise版本）
  sendWithResponse(type, payload, timeout = 10000) {
    return new Promise((resolve, reject) => {
      const messageId = this.generateMessageId();
      const message = { type, payload, messageId, timestamp: Date.now() };
      
      // 设置超时
      const timeoutId = setTimeout(() => {
        reject(new Error(`请求${type}超时`));
        this.requestQueue.delete(messageId);
      }, timeout);
      
      // 存储请求信息
      this.requestQueue.set(messageId, {
        type, 
        payload, 
        resolve: (response) => {
          clearTimeout(timeoutId);
          resolve(response);
        },
        reject: (error) => {
          clearTimeout(timeoutId);
          reject(error);
        }
      });
      
      if (this.isMockMode) {
        // Mock响应处理
        this.handleMockResponse(type, payload, messageId);
      } else {
        const messageString = JSON.stringify(message);
        
        if (this.isConnected && this.socket) {
          try {
            this.socket.send(messageString);
          } catch (error) {
            reject(new Error(`发送消息失败: ${error.message}`));
            this.requestQueue.delete(messageId);
          }
        } else {
          reject(new Error('WebSocket未连接'));
          this.requestQueue.delete(messageId);
        }
      }
    });
  }

  // 处理Mock响应
  handleMockResponse(type, payload, messageId) {
    // 模拟网络延迟
    setTimeout(() => {
      let response;
      
      switch (type) {
        case 'auth.login':
          response = this.mockLoginResponse(payload);
          break;
        case 'auth.register':
          response = this.mockRegisterResponse(payload);
          break;
        case 'chat.message':
          response = this.mockChatResponse(payload);
          break;
        case 'auth.logout':
          response = this.mockLogoutResponse(payload);
          break;
        case 'user.profile':
          response = this.mockUserProfileResponse(payload);
          break;
        default:
          response = { success: false, error: '未知消息类型' };
      }
      
      if (response) {
        this.handleMessage({ 
          type: `${type}.response`, 
          payload: response,
          messageId,
          timestamp: Date.now()
        });
      }
    }, 300 + Math.random() * 700); // 更真实的延迟范围
  }

  // Mock登录响应
  mockLoginResponse({ email, password }) {
    // 基本验证
    if (!email || !password) {
      return { success: false, error: '请输入邮箱和密码' };
    }
    
    const users = JSON.parse(localStorage.getItem('users') || '[]');
    const foundUser = users.find(user => user.email === email && user.password === password);
    
    if (!foundUser) {
      return { success: false, error: '邮箱或密码错误' };
    }
    
    const userData = { 
      id: foundUser.id, 
      username: foundUser.username, 
      email: foundUser.email,
      role: foundUser.role || 'user',
      lastLogin: Date.now()
    };
    
    // 保存登录状态
    localStorage.setItem('currentUser', JSON.stringify(userData));
    
    return { 
      success: true, 
      data: userData, 
      token: `mock_token_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` 
    };
  }

  // Mock注册响应
  mockRegisterResponse({ username, email, password }) {
    // 基本验证
    if (!username || !email || !password) {
      return { success: false, error: '请填写所有必填字段' };
    }
    
    // 邮箱格式验证
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return { success: false, error: '请输入有效的邮箱地址' };
    }
    
    // 密码强度验证
    if (password.length < 6) {
      return { success: false, error: '密码长度至少为6位' };
    }
    
    const users = JSON.parse(localStorage.getItem('users') || '[]');
    const existingUser = users.find(user => user.email === email);
    
    if (existingUser) {
      return { success: false, error: '该邮箱已被注册' };
    }
    
    const newUser = {
      id: Date.now(),
      username,
      email,
      password,
      role: 'user',
      createdAt: Date.now(),
      lastLogin: null
    };
    
    users.push(newUser);
    localStorage.setItem('users', JSON.stringify(users));
    
    return { 
      success: true, 
      data: { 
        id: newUser.id, 
        username: newUser.username, 
        email: newUser.email,
        role: newUser.role,
        createdAt: newUser.createdAt
      } 
    };
  }

  // Mock聊天响应
  mockChatResponse({ message }) {
    // 初始化对话历史
    if (!localStorage.getItem('mockChatHistory')) {
      localStorage.setItem('mockChatHistory', JSON.stringify([]));
    }
    
    // 获取对话历史
    const chatHistory = JSON.parse(localStorage.getItem('mockChatHistory')) || [];
    
    // 保存用户消息到历史
    chatHistory.push({
      role: 'user',
      content: message,
      timestamp: Date.now()
    });
    
    // AI回复模板
    const responses = {
      greeting: [
        '你好！很高兴见到你。有什么我可以帮助你的吗？',
        '嗨！欢迎和我交流。我能为你做些什么？',
        '你好！我是你的AI助手，随时为你提供帮助。',
        '嗨！很高兴认识你。请问有什么可以帮到你的？',
        '你好呀！我是DeepSeek Assistant，今天我能为你做些什么？'
      ],
      farewell: [
        '再见！有需要时随时找我。',
        '期待下次与你交流！',
        '拜拜！祝你有愉快的一天！',
        '期待再次为你服务，再见！',
        '祝你一切顺利！'
      ],
      thanks: [
        '不客气！能帮到你我很开心。',
        '随时为你服务！',
        '这是我的荣幸！',
        '很高兴可以帮到你！',
        '不客气，有问题随时问我。'
      ],
      question: [
        '这是个很好的问题。根据我的理解，',
        '我来帮你解答这个问题。首先，',
        '让我思考一下这个问题...通常来说，',
        '关于这个问题，我的看法是',
        '这个问题很有意思。从多个角度来看，',
        '根据我的知识，这个问题的答案是',
        '要回答这个问题，我们可以从几个方面来分析：'
      ],
      technology: [
        '关于技术问题，我可以提供一些见解。',
        '这是一个常见的技术挑战。解决方案通常是...',
        '根据最新的技术趋势，这个问题可以这样解决：',
        '作为开发人员，我理解这类问题的重要性。最佳实践是...',
        '从技术角度来看，这涉及到几个核心概念：'
      ],
      programming: [
        '编程是一个广阔的领域。关于你的问题，我建议...',
        '这个编程问题需要考虑几个关键点：',
        '作为程序员，我理解你面临的挑战。解决这个问题的思路是...',
        '代码实现时需要注意以下几点：',
        '这是一个常见的编程模式，可以这样实现：'
      ],
      aboutMe: [
        '我是一个人工智能助手，可以帮助你解答各种问题。',
        '我是DeepSeek Assistant，一个专注于提供有用信息和帮助的AI。',
        '我设计的初衷是为用户提供准确、有价值的信息。',
        '我不断学习新知识，以便更好地为你服务。',
        '我可以帮助你解决问题、提供信息或者只是聊天。'
      ],
      affirmation: [
        '是的，你说得对。',
        '我同意你的观点。',
        '这是一个很好的观察。',
        '没错，这个想法很有价值。',
        '你提出了一个重要的点。'
      ],
      explanation: [
        '让我来解释一下这个概念：',
        '简单来说，这是指...',
        '为了更好地理解这个问题，我们可以这样看：',
        '这个过程的工作原理是：',
        '我们可以通过以下方式来理解这个概念：'
      ],
      general: [
        '感谢你的提问！我是一个AI助手，可以帮助你解决各种问题。',
        '我理解你的需求。让我来帮你分析一下这个问题。',
        '你提出了一个很好的观点。让我们进一步探讨。',
        '这是一个复杂的问题，但我们可以一步步来解决。',
        '很高兴能帮助你！还有其他我可以为你提供帮助的吗？',
        '根据我的知识，我可以为你提供一些见解...',
        '这个话题很有意思，我们可以深入讨论。',
        '我理解这个问题的复杂性。让我尝试从不同角度来分析。',
        '这个问题有几个关键点需要考虑。',
        '让我来组织一下思路，然后给你一个全面的回答。'
      ]
    };
    
    // 扩展关键词匹配逻辑
    let responseType = 'general';
    const lowerMessage = message.toLowerCase();
    
    // 问候语匹配
    if (this.containsAny(message, ['你好', '嗨', '早上好', '晚上好', '嗨！', '你好！'])) {
      responseType = 'greeting';
    }
    // 告别匹配
    else if (this.containsAny(message, ['再见', '拜拜', '下次见', '回头见'])) {
      responseType = 'farewell';
    }
    // 感谢匹配
    else if (this.containsAny(message, ['谢谢', '感谢', '非常感谢', '太感谢了'])) {
      responseType = 'thanks';
    }
    // 关于AI自身的问题
    else if (this.containsAny(message, ['你是谁', '你叫什么', '你是做什么的', '介绍一下自己'])) {
      responseType = 'aboutMe';
    }
    // 确认性问题
    else if (this.containsAny(message, ['对吗', '是不是', '对吧', '正确吗'])) {
      responseType = 'affirmation';
    }
    // 解释类问题
    else if (this.containsAny(message, ['什么是', '什么叫', '如何理解', '解释一下', '含义是'])) {
      responseType = 'explanation';
    }
    // 技术相关问题
    else if (this.containsAny(lowerMessage, ['技术', '后端', '前端', '架构', '框架', '数据库', '服务器', '云服务'])) {
      responseType = 'technology';
    }
    // 编程相关问题
    else if (this.containsAny(lowerMessage, ['编程', '代码', '开发', 'javascript', 'python', 'java', 'c++', 'html', 'css', 'react', 'vue'])) {
      responseType = 'programming';
    }
    // 问号问题
    else if (message.includes('?') || message.includes('？') || 
             this.startsWithAny(message, ['为什么', '怎么', '如何', '什么', '哪', '谁', '何时', '何地'])) {
      responseType = 'question';
    }
    
    // 获取基本回复
    const contentArray = responses[responseType];
    let content = contentArray[Math.floor(Math.random() * contentArray.length)];
    
    // 针对问题和解释类型，添加更详细的内容
    if (responseType === 'question' || responseType === 'explanation' || 
        responseType === 'technology' || responseType === 'programming') {
      const detailedResponses = [
        '首先需要考虑问题的根本原因。然后，我们可以探索几种可能的解决方案。每种方案都有其优缺点，需要根据具体情况选择最合适的一种。',
        '这个问题涉及到多个方面，包括基础知识、最佳实践和具体实现细节。让我一步步为你分析，帮助你全面理解这个问题。',
        '要解决这个问题，我们可以采用结构化的方法：定义问题、分析可能的原因、设计解决方案、实施并测试。这种方法可以确保我们不会遗漏重要的细节。',
        '在实际应用中，我们通常会遇到各种挑战。重要的是保持灵活的思维方式，并根据具体情况调整我们的方法。',
        '从理论上讲，这个概念是这样工作的。但在实际应用中，我们需要考虑各种约束条件和现实因素。'
      ];
      
      const detailedContent = detailedResponses[Math.floor(Math.random() * detailedResponses.length)];
      content += ' ' + detailedContent;
    }
    
    // 随机添加结束语
    if (Math.random() > 0.7) {
      const endings = [
        ' 希望这对你有帮助！',
        ' 你还有其他问题吗？',
        ' 需要我进一步解释吗？',
        ' 这是我的建议，你觉得如何？',
        ' 你对这个解答满意吗？'
      ];
      content += endings[Math.floor(Math.random() * endings.length)];
    }
    
    // 保存AI回复到历史
    chatHistory.push({
      role: 'assistant',
      content,
      timestamp: Date.now()
    });
    
    // 限制历史记录长度
    if (chatHistory.length > 50) {
      chatHistory.splice(0, chatHistory.length - 50);
    }
    
    // 更新历史记录
    localStorage.setItem('mockChatHistory', JSON.stringify(chatHistory));
    
    return { 
      success: true, 
      data: { 
        content, 
        timestamp: Date.now(),
        messageId: this.generateMessageId(),
        sender: 'ai'
      } 
    };
  }
  
  // 辅助函数：检查字符串是否包含任何指定的子字符串
  containsAny(str, substrings) {
    return substrings.some(substr => str.includes(substr));
  }
  
  // 辅助函数：检查字符串是否以任何指定的前缀开头
  startsWithAny(str, prefixes) {
    return prefixes.some(prefix => str.startsWith(prefix));
  }
  
  // Mock登出响应
  mockLogoutResponse() {
    // 清除当前用户信息
    localStorage.removeItem('currentUser');
    return { success: true, message: '登出成功' };
  }
  
  // Mock用户信息响应
  mockUserProfileResponse() {
    const currentUser = localStorage.getItem('currentUser');
    if (!currentUser) {
      return { success: false, error: '用户未登录' };
    }
    return { success: true, data: JSON.parse(currentUser) };
  }

  // 注册消息处理器
  on(type, handler) {
    if (!this.messageHandlers.has(type)) {
      this.messageHandlers.set(type, []);
    }
    this.messageHandlers.get(type).push(handler);
    
    // 返回取消订阅函数
    return () => {
      const handlers = this.messageHandlers.get(type);
      if (handlers) {
        const index = handlers.indexOf(handler);
        if (index > -1) {
          handlers.splice(index, 1);
        }
      }
    };
  }

  // 通知所有处理器
  notifyHandlers(type, payload) {
    const handlers = this.messageHandlers.get(type);
    if (handlers) {
      handlers.forEach(handler => {
        try {
          handler(payload);
        } catch (error) {
          console.error(`处理${type}消息时出错:`, error);
        }
      });
    }
  }

  // 关闭连接
  disconnect() {
    if (this.socket) {
      this.socket.close();
      this.socket = null;
    }
    this.isConnected = false;
    this.messageHandlers.clear();
  }

  // 切换到真实WebSocket模式 - 内部方法，不对外暴露
  _switchToRealMode(wsUrl) {
    // 此方法保留但不应被调用，因为我们强制使用mock模式
    console.warn('尝试切换到真实模式，但已配置为始终使用Mock模式');
    // 不执行实际的模式切换
  }

  // 切换到Mock模式 - 内部方法，不对外暴露
  _switchToMockMode() {
    // 已经是mock模式，不需要做任何操作
    console.log('已经在Mock模式');
  }
}

// 导出单例实例
export default new WebSocketService();